#include "script.h"

#include <string>
#include <ctime>

#pragma warning(disable : 4244 4305) // double <-> float conversions

std::string statusText;
DWORD statusTextDrawTicksMax;
bool statusTextGxtEntry;
bool keyDown = false;

int hydraSpawned = 0;
int savageSpawned = 0;
int valkyrieSpawned = 0;
int cascoSpawned = 0;
int insurgentSpawned = 0;
int insurgent2Spawned = 0;
int guardianSpawned = 0;
int technicalSpawned = 0;
int enduroSpawned = 0;
int kurumaSpawned = 0;
int kuruma2Spawned = 0;
int lectroSpawned = 0;
int velum2Spawned = 0;
int slamvan2Spawned = 0;
int mule3Spawned = 0;
int boxville4Spawned = 0;
int gburrito2Spawned = 0;
//////////////////////////////////
int kuruma2DrivingSpawned = 0;
int kurumaDrivingSpawned = 0;
int lectroDrivingSpawned = 0;
int cascoDrivingSpawned = 0;
int guardianDrivingSpawned = 0;
int enduroDrivingSpawned = 0;

Vehicle hydraVeh, savageVeh, valkyrieVeh, cascoVeh, insurgentVeh, insurgent2Veh, guardianVeh, technicalVeh, enduroVeh, kurumaVeh, kuruma2Veh, lectroVeh, velum2Veh, slamvan2Veh, mule3Veh, boxville4Veh, gburrito2Veh,
electroDrivingVeh, lectroDrivingVeh, kurumaDrivingVeh, kuruma2DrivingVeh, guardianDrivingVeh, cascoDrivingVeh, enduroDrivingVeh;
bool showText = true;

void update_status_text()
{
	if (showText == true)
	{
		UI::SET_TEXT_FONT(0);
		UI::SET_TEXT_SCALE(0.0, 0.0);
		UI::SET_TEXT_COLOUR(255, 255, 255, 255);
		UI::SET_TEXT_WRAP(0.0, 1.0);
		UI::SET_TEXT_CENTRE(1);
		UI::SET_TEXT_DROPSHADOW(0, 0, 0, 0, 0);
		UI::SET_TEXT_EDGE(1, 0, 0, 0, 205);
		if (statusTextGxtEntry)
		{
			UI::_SET_TEXT_ENTRY((char *)statusText.c_str());
		}
		else
		{
			UI::_SET_TEXT_ENTRY("STRING");
			UI::_ADD_TEXT_COMPONENT_STRING((char *)statusText.c_str());
		}
		UI::_DRAW_TEXT(0.0, 0.0);
	}
}

void set_status_text(std::string str, DWORD time = 2500, bool isGxtEntry = false)
{
	statusText = str;
	statusTextDrawTicksMax = time;
	statusTextGxtEntry = isGxtEntry;
}

void update()
{
	Ped playerPed = PLAYER::PLAYER_PED_ID();
	Vehicle veh = PED::GET_VEHICLE_PED_IS_USING(playerPed);
	Vector3 position = ENTITY::GET_ENTITY_COORDS(playerPed, 1);

	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL hydraExist = ENTITY::DOES_ENTITY_EXIST(hydraVeh);
	DWORD hydra = GAMEPLAY::GET_HASH_KEY("HYDRA");
	int hydraSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-2750.30f, 3287.47f, 33.35f, position.x, position.y, position.z, 0);

	if (hydraSpawnDistance < 1000)
	{
		if (hydraSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(hydra);
			while (!STREAMING::HAS_MODEL_LOADED(hydra))
				WAIT(0);
			hydraVeh = VEHICLE::CREATE_VEHICLE(hydra, -2750.30f, 3287.47f, 33.35f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(hydraVeh, 240.34f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(hydraVeh);
			hydraSpawned += 1;
		}
	}

	Vector3 hydraVehPosition = ENTITY::GET_ENTITY_COORDS(hydraVeh, 1);
	int hydraVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(hydraVehPosition.x, hydraVehPosition.y, hydraVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(hydraVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&hydraVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, hydraVeh, 0) && hydraVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&hydraVeh);
	}
	if (hydraSpawnDistance > 1000 && hydraVehDistance > 1000)
	{
		if (hydraSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&hydraVeh);
			hydraSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL savageExist = ENTITY::DOES_ENTITY_EXIST(savageVeh);
	DWORD savage = GAMEPLAY::GET_HASH_KEY("SAVAGE");
	int savageSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1929.27f, 3119.41f, 33.30f, position.x, position.y, position.z, 0);

	if (savageSpawnDistance < 1000)
	{
		if (savageSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(savage);
			while (!STREAMING::HAS_MODEL_LOADED(savage))
				WAIT(0);
			savageVeh = VEHICLE::CREATE_VEHICLE(savage, -1929.27f, 3119.41f, 33.30f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(savageVeh, 149.87f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(savageVeh);
			savageSpawned += 1;
		}
	}

	Vector3 savageVehPosition = ENTITY::GET_ENTITY_COORDS(savageVeh, 1);
	int savageVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(savageVehPosition.x, savageVehPosition.y, savageVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(savageVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&savageVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, savageVeh, 0) && savageVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&savageVeh);
	}
	if (savageSpawnDistance > 1000 && savageVehDistance > 1000)
	{
		if (savageSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&savageVeh);
			savageSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL valkyrieExist = ENTITY::DOES_ENTITY_EXIST(valkyrieVeh);
	DWORD valkyrie = GAMEPLAY::GET_HASH_KEY("VALKYRIE");
	int valkyrieSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(503.39f, -3378.00f, 6.45f, position.x, position.y, position.z, 0);

	if (valkyrieSpawnDistance < 1000)
	{
		if (valkyrieSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(valkyrie);
			while (!STREAMING::HAS_MODEL_LOADED(valkyrie))
				WAIT(0);
			valkyrieVeh = VEHICLE::CREATE_VEHICLE(valkyrie, 503.39f, -3378.00f, 6.45f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(valkyrieVeh, 37.48f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(valkyrieVeh);
			valkyrieSpawned += 1;
		}
	}

	Vector3 valkyrieVehPosition = ENTITY::GET_ENTITY_COORDS(valkyrieVeh, 1);
	int valkyrieVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(valkyrieVehPosition.x, valkyrieVehPosition.y, valkyrieVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(valkyrieVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&valkyrieVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, valkyrieVeh, 0) && valkyrieVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&valkyrieVeh);
	}
	if (valkyrieSpawnDistance > 1000 && valkyrieVehDistance > 1000)
	{
		if (valkyrieSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&valkyrieVeh);
			valkyrieSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL cascoExist = ENTITY::DOES_ENTITY_EXIST(cascoVeh);
	DWORD casco = GAMEPLAY::GET_HASH_KEY("CASCO");
	int cascoSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1124.94f, -2172.13f, 12.46f, position.x, position.y, position.z, 0);

	if (cascoSpawnDistance < 1000)
	{
		if (cascoSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(casco);
			while (!STREAMING::HAS_MODEL_LOADED(casco))
				WAIT(0);
			cascoVeh = VEHICLE::CREATE_VEHICLE(casco, -1124.94f, -2172.13f, 12.46f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(cascoVeh, 164.18f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(cascoVeh);
			cascoSpawned += 1;
		}
	}

	Vector3 cascoVehPosition = ENTITY::GET_ENTITY_COORDS(cascoVeh, 1);
	int cascoVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(cascoVehPosition.x, cascoVehPosition.y, cascoVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(cascoVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cascoVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, cascoVeh, 0) && cascoVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cascoVeh);
	}
	if (cascoSpawnDistance > 1000 && cascoVehDistance > 1000)
	{
		if (cascoSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cascoVeh);
			cascoSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL insurgentExist = ENTITY::DOES_ENTITY_EXIST(insurgentVeh);
	DWORD insurgent = GAMEPLAY::GET_HASH_KEY("INSURGENT");
	int insurgentSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(473.16f, -3092.41f, 5.99f, position.x, position.y, position.z, 0);

	if (insurgentSpawnDistance < 1000)
	{
		if (insurgentSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(insurgent);
			while (!STREAMING::HAS_MODEL_LOADED(insurgent))
				WAIT(0);
			insurgentVeh = VEHICLE::CREATE_VEHICLE(insurgent, 473.16f, -3092.41f, 5.99f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(insurgentVeh, 179.92f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(insurgentVeh);
			insurgentSpawned += 1;
		}
	}

	Vector3 insurgentVehPosition = ENTITY::GET_ENTITY_COORDS(insurgentVeh, 1);
	int insurgentVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(insurgentVehPosition.x, insurgentVehPosition.y, insurgentVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(insurgentVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&insurgentVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, insurgentVeh, 0) && insurgentVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&insurgentVeh);
	}
	if (insurgentSpawnDistance > 1000 && insurgentVehDistance > 1000)
	{
		if (insurgentSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&insurgentVeh);
			insurgentSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL insurgent2Exist = ENTITY::DOES_ENTITY_EXIST(insurgent2Veh);
	DWORD insurgent2 = GAMEPLAY::GET_HASH_KEY("insurgent2");
	int insurgent2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(472.92f, -3079.00f, 6.01f, position.x, position.y, position.z, 0);

	if (insurgent2SpawnDistance < 1000)
	{
		if (insurgent2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(insurgent2);
			while (!STREAMING::HAS_MODEL_LOADED(insurgent2))
				WAIT(0);
			insurgent2Veh = VEHICLE::CREATE_VEHICLE(insurgent2, 472.92f, -3079.00f, 6.01f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(insurgent2Veh, 180.25f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(insurgent2Veh);
			insurgent2Spawned += 1;
		}
	}

	Vector3 insurgent2VehPosition = ENTITY::GET_ENTITY_COORDS(insurgent2Veh, 1);
	int insurgent2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(insurgent2VehPosition.x, insurgent2VehPosition.y, insurgent2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(insurgent2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&insurgent2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, insurgent2Veh, 0) && insurgent2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&insurgent2Veh);
	}
	if (insurgent2SpawnDistance > 1000 && insurgent2VehDistance > 1000)
	{
		if (insurgent2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&insurgent2Veh);
			insurgent2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL guardianExist = ENTITY::DOES_ENTITY_EXIST(guardianVeh);
	DWORD guardian = GAMEPLAY::GET_HASH_KEY("guardian");
	int guardianSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-155.73f, -1017.26f, 21.5f, position.x, position.y, position.z, 0);

	if (guardianSpawnDistance < 1000)
	{
		if (guardianSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(guardian);
			while (!STREAMING::HAS_MODEL_LOADED(guardian))
				WAIT(0);
			guardianVeh = VEHICLE::CREATE_VEHICLE(guardian, -155.73f, -1017.26f, 21.5f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(guardianVeh, 18.36f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(guardianVeh);
			guardianSpawned += 1;
		}
	}

	Vector3 guardianVehPosition = ENTITY::GET_ENTITY_COORDS(guardianVeh, 1);
	int guardianVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(guardianVehPosition.x, guardianVehPosition.y, guardianVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(guardianVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&guardianVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, guardianVeh, 0) && guardianVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&guardianVeh);
	}
	if (guardianSpawnDistance > 1000 && guardianVehDistance > 1000)
	{
		if (guardianSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&guardianVeh);
			guardianSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL technicalExist = ENTITY::DOES_ENTITY_EXIST(technicalVeh);
	DWORD technical = GAMEPLAY::GET_HASH_KEY("technical");
	int technicalSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(2716.05f, 4130.53f, 43.47f, position.x, position.y, position.z, 0);

	if (technicalSpawnDistance < 1000)
	{
		if (technicalSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(technical);
			while (!STREAMING::HAS_MODEL_LOADED(technical))
				WAIT(0);
			technicalVeh = VEHICLE::CREATE_VEHICLE(technical, 2716.05f, 4130.53f, 43.47f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(technicalVeh, 38.06f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(technicalVeh);
			technicalSpawned += 1;
		}
	}

	Vector3 technicalVehPosition = ENTITY::GET_ENTITY_COORDS(technicalVeh, 1);
	int technicalVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(technicalVehPosition.x, technicalVehPosition.y, technicalVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(technicalVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&technicalVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, technicalVeh, 0) && technicalVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&technicalVeh);
	}
	if (technicalSpawnDistance > 1000 && technicalVehDistance > 1000)
	{
		if (technicalSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&technicalVeh);
			technicalSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL enduroExist = ENTITY::DOES_ENTITY_EXIST(enduroVeh);
	DWORD enduro = GAMEPLAY::GET_HASH_KEY("enduro");
	int enduroSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(2821.46f, 5975.24f, 349.75f, position.x, position.y, position.z, 0);

	if (enduroSpawnDistance < 1000)
	{
		if (enduroSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(enduro);
			while (!STREAMING::HAS_MODEL_LOADED(enduro))
				WAIT(0);
			enduroVeh = VEHICLE::CREATE_VEHICLE(enduro, 2821.46f, 5975.24f, 349.75f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(enduroVeh, 172.64f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(enduroVeh);
			enduroSpawned += 1;
		}
	}

	Vector3 enduroVehPosition = ENTITY::GET_ENTITY_COORDS(enduroVeh, 1);
	int enduroVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(enduroVehPosition.x, enduroVehPosition.y, enduroVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(enduroVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&enduroVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, enduroVeh, 0) && enduroVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&enduroVeh);
	}
	if (enduroSpawnDistance > 1000 && enduroVehDistance > 1000)
	{
		if (enduroSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&enduroVeh);
			enduroSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL kurumaExist = ENTITY::DOES_ENTITY_EXIST(kurumaVeh);
	DWORD kuruma = GAMEPLAY::GET_HASH_KEY("kuruma");
	int kurumaSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(2369.60f, 2284.40f, 93.77f, position.x, position.y, position.z, 0);

	if (kurumaSpawnDistance < 1000)
	{
		if (kurumaSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(kuruma);
			while (!STREAMING::HAS_MODEL_LOADED(kuruma))
				WAIT(0);
			kurumaVeh = VEHICLE::CREATE_VEHICLE(kuruma, 2369.60f, 2284.40f, 93.77f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(kurumaVeh, 294.51f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(kurumaVeh);
			kurumaSpawned += 1;
		}
	}

	Vector3 kurumaVehPosition = ENTITY::GET_ENTITY_COORDS(kurumaVeh, 1);
	int kurumaVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(kurumaVehPosition.x, kurumaVehPosition.y, kurumaVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(kurumaVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kurumaVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, kurumaVeh, 0) && kurumaVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kurumaVeh);
	}
	if (kurumaSpawnDistance > 1000 && kurumaVehDistance > 1000)
	{
		if (kurumaSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kurumaVeh);
			kurumaSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL kuruma2Exist = ENTITY::DOES_ENTITY_EXIST(kuruma2Veh);
	DWORD kuruma2 = GAMEPLAY::GET_HASH_KEY("kuruma2");
	int kuruma2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(667.20f, -2190.64f, 3.40f, position.x, position.y, position.z, 0);

	if (kuruma2SpawnDistance < 1000)
	{
		if (kuruma2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(kuruma2);
			while (!STREAMING::HAS_MODEL_LOADED(kuruma2))
				WAIT(0);
			kuruma2Veh = VEHICLE::CREATE_VEHICLE(kuruma2, 667.20f, -2190.64f, 3.40f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(kuruma2Veh, 134.72f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(kuruma2Veh);
			kuruma2Spawned += 1;
		}
	}

	Vector3 kuruma2VehPosition = ENTITY::GET_ENTITY_COORDS(kuruma2Veh, 1);
	int kuruma2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(kuruma2VehPosition.x, kuruma2VehPosition.y, kuruma2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(kuruma2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kuruma2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, kuruma2Veh, 0) && kuruma2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kuruma2Veh);
	}
	if (kuruma2SpawnDistance > 1000 && kuruma2VehDistance > 1000)
	{
		if (kuruma2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kuruma2Veh);
			kuruma2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL lectroExist = ENTITY::DOES_ENTITY_EXIST(lectroVeh);
	DWORD lectro = GAMEPLAY::GET_HASH_KEY("lectro");
	int lectroSpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-429.83f, 1202.47f, 325.29f, position.x, position.y, position.z, 0);

	if (lectroSpawnDistance < 1000)
	{
		if (lectroSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(lectro);
			while (!STREAMING::HAS_MODEL_LOADED(lectro))
				WAIT(0);
			lectroVeh = VEHICLE::CREATE_VEHICLE(lectro, -429.83f, 1202.47f, 325.29f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(lectroVeh, 201.90f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(lectroVeh);
			lectroSpawned += 1;
		}
	}

	Vector3 lectroVehPosition = ENTITY::GET_ENTITY_COORDS(lectroVeh, 1);
	int lectroVehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(lectroVehPosition.x, lectroVehPosition.y, lectroVehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(lectroVeh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&lectroVeh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, lectroVeh, 0) && lectroVehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&lectroVeh);
	}
	if (lectroSpawnDistance > 1000 && lectroVehDistance > 1000)
	{
		if (lectroSpawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&lectroVeh);
			lectroSpawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL velum2Exist = ENTITY::DOES_ENTITY_EXIST(velum2Veh);
	DWORD velum2 = GAMEPLAY::GET_HASH_KEY("velum2");
	int velum2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-949.67f, -3072.69f, 14.88f, position.x, position.y, position.z, 0);

	if (velum2SpawnDistance < 1000)
	{
		if (velum2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(velum2);
			while (!STREAMING::HAS_MODEL_LOADED(velum2))
				WAIT(0);
			velum2Veh = VEHICLE::CREATE_VEHICLE(velum2, -949.67f, -3072.69f, 14.88f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(velum2Veh, 102.10f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(velum2Veh);
			velum2Spawned += 1;
		}
	}

	Vector3 velum2VehPosition = ENTITY::GET_ENTITY_COORDS(velum2Veh, 1);
	int velum2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(velum2VehPosition.x, velum2VehPosition.y, velum2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(velum2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&velum2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, velum2Veh, 0) && velum2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&velum2Veh);
	}
	if (velum2SpawnDistance > 1000 && velum2VehDistance > 1000)
	{
		if (velum2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&velum2Veh);
			velum2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL slamvan2Exist = ENTITY::DOES_ENTITY_EXIST(slamvan2Veh);
	DWORD slamvan2 = GAMEPLAY::GET_HASH_KEY("slamvan2");
	int slamvan2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(59.45f, 3702.51f, 39.39f, position.x, position.y, position.z, 0);

	if (slamvan2SpawnDistance < 1000)
	{
		if (slamvan2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(slamvan2);
			while (!STREAMING::HAS_MODEL_LOADED(slamvan2))
				WAIT(0);
			slamvan2Veh = VEHICLE::CREATE_VEHICLE(slamvan2, 59.45f, 3702.51f, 39.39f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(slamvan2Veh, 11.74f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(slamvan2Veh);
			slamvan2Spawned += 1;
		}
	}

	Vector3 slamvan2VehPosition = ENTITY::GET_ENTITY_COORDS(slamvan2Veh, 1);
	int slamvan2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(slamvan2VehPosition.x, slamvan2VehPosition.y, slamvan2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(slamvan2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&slamvan2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, slamvan2Veh, 0) && slamvan2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&slamvan2Veh);
	}
	if (slamvan2SpawnDistance > 1000 && slamvan2VehDistance > 1000)
	{
		if (slamvan2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&slamvan2Veh);
			slamvan2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL mule3Exist = ENTITY::DOES_ENTITY_EXIST(mule3Veh);
	DWORD mule3 = GAMEPLAY::GET_HASH_KEY("mule3");
	int mule3SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(3575.40f, 3671.35f, 34.12f, position.x, position.y, position.z, 0);

	if (mule3SpawnDistance < 1000)
	{
		if (mule3Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(mule3);
			while (!STREAMING::HAS_MODEL_LOADED(mule3))
				WAIT(0);
			mule3Veh = VEHICLE::CREATE_VEHICLE(mule3, 3575.40f, 3671.35f, 34.12f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(mule3Veh, 96.89f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(mule3Veh);
			mule3Spawned += 1;
		}
	}

	Vector3 mule3VehPosition = ENTITY::GET_ENTITY_COORDS(mule3Veh, 1);
	int mule3VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(mule3VehPosition.x, mule3VehPosition.y, mule3VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(mule3Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mule3Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, mule3Veh, 0) && mule3VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mule3Veh);
	}
	if (mule3SpawnDistance > 1000 && mule3VehDistance > 1000)
	{
		if (mule3Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&mule3Veh);
			mule3Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL boxville4Exist = ENTITY::DOES_ENTITY_EXIST(boxville4Veh);
	DWORD boxville4 = GAMEPLAY::GET_HASH_KEY("boxville4");
	int boxville4SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(577.41f, -2664.88f, 6.05f, position.x, position.y, position.z, 0);

	if (boxville4SpawnDistance < 1000)
	{
		if (boxville4Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(boxville4);
			while (!STREAMING::HAS_MODEL_LOADED(boxville4))
				WAIT(0);
			boxville4Veh = VEHICLE::CREATE_VEHICLE(boxville4, 577.41f, -2664.88f, 6.05f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(boxville4Veh, 53.82f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(boxville4Veh);
			boxville4Spawned += 1;
		}
	}

	Vector3 boxville4VehPosition = ENTITY::GET_ENTITY_COORDS(boxville4Veh, 1);
	int boxville4VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(boxville4VehPosition.x, boxville4VehPosition.y, boxville4VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(boxville4Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&boxville4Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, boxville4Veh, 0) && boxville4VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&boxville4Veh);
	}
	if (boxville4SpawnDistance > 1000 && boxville4VehDistance > 1000)
	{
		if (boxville4Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&boxville4Veh);
			boxville4Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	BOOL gburrito2Exist = ENTITY::DOES_ENTITY_EXIST(gburrito2Veh);
	DWORD gburrito2 = GAMEPLAY::GET_HASH_KEY("gburrito2");
	int gburrito2SpawnDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(6.55f, -1405.51f, 29.08f, position.x, position.y, position.z, 0);

	if (gburrito2SpawnDistance < 1000)
	{
		if (gburrito2Spawned == 0)
		{
			STREAMING::REQUEST_MODEL(gburrito2);
			while (!STREAMING::HAS_MODEL_LOADED(gburrito2))
				WAIT(0);
			gburrito2Veh = VEHICLE::CREATE_VEHICLE(gburrito2, 6.55f, -1405.51f, 29.08f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(gburrito2Veh, 89.59f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(gburrito2Veh);
			gburrito2Spawned += 1;
		}
	}

	Vector3 gburrito2VehPosition = ENTITY::GET_ENTITY_COORDS(gburrito2Veh, 1);
	int gburrito2VehDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(gburrito2VehPosition.x, gburrito2VehPosition.y, gburrito2VehPosition.z, position.x, position.y, position.z, 0);

	if (!VEHICLE::IS_VEHICLE_DRIVEABLE(gburrito2Veh, 0))
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&gburrito2Veh);
	}
	if (!PED::IS_PED_IN_VEHICLE(playerPed, gburrito2Veh, 0) && gburrito2VehDistance > 1000)
	{
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&gburrito2Veh);
	}
	if (gburrito2SpawnDistance > 1000 && gburrito2VehDistance > 1000)
	{
		if (gburrito2Spawned == 1)
		{
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&gburrito2Veh);
			gburrito2Spawned -= 1;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	DWORD kuruma2Driving = GAMEPLAY::GET_HASH_KEY("kuruma");
	int kuruma2DrivingSpawnRadius = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-79.29f, -108.08f, 57.11f, position.x, position.y, position.z, 0);
	Ped kuruma2Ped;

	if (kuruma2DrivingSpawnRadius < 50)
	{
		if (kuruma2DrivingSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(kuruma2Driving);
			while (!STREAMING::HAS_MODEL_LOADED(kuruma2Driving))
				WAIT(0);
			kuruma2DrivingVeh = VEHICLE::CREATE_VEHICLE(kuruma2Driving, 153.57f, -158.50f, 54.13f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(kuruma2DrivingVeh, 175.34f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(kuruma2DrivingVeh);
			kuruma2Ped = PED::CREATE_RANDOM_PED_AS_DRIVER(kuruma2DrivingVeh, 1);
			AI::TASK_VEHICLE_DRIVE_WANDER(kuruma2Ped, kuruma2DrivingVeh, 10.0f, 153);
			kuruma2DrivingSpawned = 1;
		}
	}

	int kuruma2DrivingDistance;
	Vector3 kuruma2Position = ENTITY::GET_ENTITY_COORDS(kuruma2DrivingVeh, 1);
	kuruma2DrivingDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(kuruma2Position.x, kuruma2Position.y, kuruma2Position.z, position.x, position.y, position.z, 0);

	if (kuruma2DrivingSpawned == 1)
	{
		if (kuruma2DrivingDistance > 500)
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&kuruma2Ped);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kuruma2DrivingVeh);
			kuruma2DrivingSpawned = 0;
		}
		if (!VEHICLE::IS_VEHICLE_DRIVEABLE(kuruma2DrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&kuruma2Ped);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kuruma2DrivingVeh);
			kuruma2DrivingSpawned = 0;
		}
		if (!PED::IS_PED_IN_VEHICLE(kuruma2Ped, kuruma2DrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&kuruma2Ped);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kuruma2DrivingVeh);
			kuruma2DrivingSpawned = 0;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	DWORD kurumaDriving = GAMEPLAY::GET_HASH_KEY("kuruma");
	int kurumaDrivingSpawnRadius = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(289.23f, 163.78f, 103.52f, position.x, position.y, position.z, 0);
	Ped kurumaPed;

	if (kurumaDrivingSpawnRadius < 50)
	{
		if (kurumaDrivingSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(kurumaDriving);
			while (!STREAMING::HAS_MODEL_LOADED(kurumaDriving))
				WAIT(0);
			kurumaDrivingVeh = VEHICLE::CREATE_VEHICLE(kurumaDriving, 38.16f, 298.22f, 109.67f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(kurumaDrivingVeh, 174.19f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(kurumaDrivingVeh);
			kurumaPed = PED::CREATE_RANDOM_PED_AS_DRIVER(kurumaDrivingVeh, 1);
			AI::TASK_VEHICLE_DRIVE_WANDER(kurumaPed, kurumaDrivingVeh, 10.0f, 153);
			kurumaDrivingSpawned = 1;
		}
	}

	int kurumaDrivingDistance;
	Vector3 kurumaPosition = ENTITY::GET_ENTITY_COORDS(kurumaDrivingVeh, 1);
	kurumaDrivingDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(kurumaPosition.x, kurumaPosition.y, kurumaPosition.z, position.x, position.y, position.z, 0);

	if (kurumaDrivingSpawned == 1)
	{
		if (kurumaDrivingDistance > 500)
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&kurumaPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kurumaDrivingVeh);
			kurumaDrivingSpawned = 0;
		}
		if (!VEHICLE::IS_VEHICLE_DRIVEABLE(kurumaDrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&kurumaPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kurumaDrivingVeh);
			kurumaDrivingSpawned = 0;
		}
		if (!PED::IS_PED_IN_VEHICLE(kurumaPed, kurumaDrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&kurumaPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&kurumaDrivingVeh);
			kurumaDrivingSpawned = 0;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	DWORD lectroDriving = GAMEPLAY::GET_HASH_KEY("lectro");
	int lectroDrivingSpawnRadius = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-1768.35f, 70.42f, 67.83f, position.x, position.y, position.z, 0);
	Ped lectroPed;

	if (lectroDrivingSpawnRadius < 50)
	{
		if (lectroDrivingSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(lectroDriving);
			while (!STREAMING::HAS_MODEL_LOADED(lectroDriving))
				WAIT(0);
			lectroDrivingVeh = VEHICLE::CREATE_VEHICLE(lectroDriving, -1601.43f, 49.82f, 60.03f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(lectroDrivingVeh, 314.4f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(lectroDrivingVeh);
			lectroPed = PED::CREATE_RANDOM_PED_AS_DRIVER(lectroDrivingVeh, 1);
			AI::TASK_VEHICLE_DRIVE_WANDER(lectroPed, lectroDrivingVeh, 10.0f, 153);
			lectroDrivingSpawned = 1;
		}
	}

	int lectroDrivingDistance;
	Vector3 lectroPosition = ENTITY::GET_ENTITY_COORDS(lectroDrivingVeh, 1);
	lectroDrivingDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(lectroPosition.x, lectroPosition.y, lectroPosition.z, position.x, position.y, position.z, 0);

	if (lectroDrivingSpawned == 1)
	{
		if (lectroDrivingDistance > 500)
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&lectroPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&lectroDrivingVeh);
			lectroDrivingSpawned = 0;
		}
		if (!VEHICLE::IS_VEHICLE_DRIVEABLE(lectroDrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&lectroPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&lectroDrivingVeh);
			lectroDrivingSpawned = 0;
		}
		if (!PED::IS_PED_IN_VEHICLE(lectroPed, lectroDrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&lectroPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&lectroDrivingVeh);
			lectroDrivingSpawned = 0;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	DWORD cascoDriving = GAMEPLAY::GET_HASH_KEY("casco");
	int cascoDrivingSpawnRadius = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-748.45f, -143.99f, 36.76f, position.x, position.y, position.z, 0);
	Ped cascoPed;

	if (cascoDrivingSpawnRadius < 50)
	{
		if (cascoDrivingSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(cascoDriving);
			while (!STREAMING::HAS_MODEL_LOADED(cascoDriving))
				WAIT(0);
			cascoDrivingVeh = VEHICLE::CREATE_VEHICLE(cascoDriving, -658.91f, -192.21f, 36.85f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(cascoDrivingVeh, 130.49f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(cascoDrivingVeh);
			cascoPed = PED::CREATE_RANDOM_PED_AS_DRIVER(cascoDrivingVeh, 1);
			AI::TASK_VEHICLE_DRIVE_WANDER(cascoPed, cascoDrivingVeh, 10.0f, 153);
			cascoDrivingSpawned = 1;
		}
	}

	int cascoDrivingDistance;
	Vector3 cascoPosition = ENTITY::GET_ENTITY_COORDS(cascoDrivingVeh, 1);
	cascoDrivingDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(cascoPosition.x, cascoPosition.y, cascoPosition.z, position.x, position.y, position.z, 0);

	if (cascoDrivingSpawned == 1)
	{
		if (cascoDrivingDistance > 500)
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&cascoPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cascoDrivingVeh);
			cascoDrivingSpawned = 0;
		}
		if (!VEHICLE::IS_VEHICLE_DRIVEABLE(cascoDrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&cascoPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cascoDrivingVeh);
			cascoDrivingSpawned = 0;
		}
		if (!PED::IS_PED_IN_VEHICLE(cascoPed, cascoDrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&cascoPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&cascoDrivingVeh);
			cascoDrivingSpawned = 0;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	DWORD guardianDriving = GAMEPLAY::GET_HASH_KEY("guardian");
	int guardianDrivingSpawnRadius = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(-168.56f, 6207.60f, 30.43f, position.x, position.y, position.z, 0);
	Ped guardianPed;

	if (guardianDrivingSpawnRadius < 50)
	{
		if (guardianDrivingSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(guardianDriving);
			while (!STREAMING::HAS_MODEL_LOADED(guardianDriving))
				WAIT(0);
			guardianDrivingVeh = VEHICLE::CREATE_VEHICLE(guardianDriving, -140.87f, 6461.60f, 30.72f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(guardianDrivingVeh, 152.59f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(guardianDrivingVeh);
			guardianPed = PED::CREATE_RANDOM_PED_AS_DRIVER(guardianDrivingVeh, 1);
			AI::TASK_VEHICLE_DRIVE_WANDER(guardianPed, guardianDrivingVeh, 10.0f, 153);
			guardianDrivingSpawned = 1;
		}
	}

	int guardianDrivingDistance;
	Vector3 guardianPosition = ENTITY::GET_ENTITY_COORDS(guardianDrivingVeh, 1);
	guardianDrivingDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(guardianPosition.x, guardianPosition.y, guardianPosition.z, position.x, position.y, position.z, 0);

	if (guardianDrivingSpawned == 1)
	{
		if (guardianDrivingDistance > 500)
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&guardianPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&guardianDrivingVeh);
			guardianDrivingSpawned = 0;
		}
		if (!VEHICLE::IS_VEHICLE_DRIVEABLE(guardianDrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&guardianPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&guardianDrivingVeh);
			guardianDrivingSpawned = 0;
		}
		if (!PED::IS_PED_IN_VEHICLE(guardianPed, guardianDrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&guardianPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&guardianDrivingVeh);
			guardianDrivingSpawned = 0;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////
	DWORD enduroDriving = GAMEPLAY::GET_HASH_KEY("enduro");
	int enduroDrivingSpawnRadius = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(1643.65f, 3604.33f, 34.72f, position.x, position.y, position.z, 0);
	Ped enduroPed;

	if (enduroDrivingSpawnRadius < 50)
	{
		if (enduroDrivingSpawned == 0)
		{
			STREAMING::REQUEST_MODEL(enduroDriving);
			while (!STREAMING::HAS_MODEL_LOADED(enduroDriving))
				WAIT(0);
			enduroDrivingVeh = VEHICLE::CREATE_VEHICLE(enduroDriving, 1794.38f, 3859.46f, 33.54f, 0.0, 1, 1);
			ENTITY::SET_ENTITY_HEADING(enduroDrivingVeh, 111.90f);
			VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(enduroDrivingVeh);
			enduroPed = PED::CREATE_RANDOM_PED_AS_DRIVER(enduroDrivingVeh, 1);
			AI::TASK_VEHICLE_DRIVE_WANDER(enduroPed, enduroDrivingVeh, 10.0f, 153);
			enduroDrivingSpawned = 1;
		}
	}

	int enduroDrivingDistance;
	Vector3 enduroPosition = ENTITY::GET_ENTITY_COORDS(enduroDrivingVeh, 1);
	enduroDrivingDistance = GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(enduroPosition.x, enduroPosition.y, enduroPosition.z, position.x, position.y, position.z, 0);

	if (enduroDrivingSpawned == 1)
	{
		if (enduroDrivingDistance > 500)
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&enduroPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&enduroDrivingVeh);
			enduroDrivingSpawned = 0;
		}
		if (!VEHICLE::IS_VEHICLE_DRIVEABLE(enduroDrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&enduroPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&enduroDrivingVeh);
			enduroDrivingSpawned = 0;
		}
		if (!PED::IS_PED_IN_VEHICLE(enduroPed, enduroDrivingVeh, 0))
		{
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&enduroPed);
			ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&enduroDrivingVeh);
			enduroDrivingSpawned = 0;
		}
	}
	/////////////////////////////////////////////////////////////////////////////////////////////

	std::string HS = std::to_string(kuruma2DrivingSpawnRadius);
	std::string HS2 = std::to_string(kuruma2DrivingSpawned);
	std::string HS3 = std::to_string(guardianExist);
	std::string HS4 = std::to_string(kuruma2DrivingDistance);

	set_status_text("" + HS + "     " + HS2 + "        " + HS3 + "     " + HS4);
	update_status_text(); //uncomment this for developer mode*/
}

void main()
{
	while (true)
	{
		update();
		WAIT(0);
	}
}

void ScriptMain()
{
	srand(GetTickCount());
	main();
}

